import Repl from '@/repl/Repl.tsx';
import CodeLink from '@/mdx-components/CodeLink.tsx';

# Seq.Indexed

<CodeLink to="../Seq" /> which represents an ordered indexed list of values.

<Signature code="type Seq.Indexed<T> extends Seq<number, T>, Collection.Indexed<T>" />

## Construction

<MemberLabel label="Seq.Indexed()" />

Always returns Seq.Indexed, discarding associated keys and supplying incrementing indices.

<Signature code="Seq.Indexed<T>(collection?: Iterable<T> | ArrayLike<T>): Seq.Indexed<T>" />

Note: `Seq.Indexed` is a conversion function and not a class, and does not use the new keyword during construction.

## Static methods

<MemberLabel label="Seq.Indexed.of()" />

Provides an Seq.Indexed of the values provided.

<Signature code="Seq.Indexed.of<T>(...values: Array<T>): Seq.Indexed<T>" />

## Reading values

<MemberLabel label="get()" />

Returns the value associated with the provided index, or notSetValue if the index is beyond the bounds of the Collection.

<Signature
  code={`get<NSV>(key: number, notSetValue: NSV): T | NSV;
get(key: number): T | undefined;`}
/>

`index` may be a negative number, which indexes back from the end of the Collection. `s.get(-1)` gets the last item in the Collection.

<MemberLabel label="has()" />

True if a key exists within this `Collection`, using `Immutable.is` to determine equality.

<Signature code={`has(key: number): boolean;`} />

<MemberLabel label="includes()" alias="contains()" />

True if a value exists within this `Collection`, using `Immutable.is` to determine equality.

<Signature code={`includes(value: T): boolean;`} />

<MemberLabel label="first()" />

In case the `Collection` is not empty returns the first element of the `Collection`. In case the `Collection` is empty returns the optional default value if provided, if no default value is provided returns undefined.

<Signature
  code={`first<NSV>(notSetValue: NSV): T | NSV;
first(): T | undefined;`}
/>

<MemberLabel label="last()" />

In case the `Collection` is not empty returns the last element of the `Collection`. In case the `Collection` is empty returns the optional default value if provided, if no default value is provided returns undefined.

<Signature
  code={`last<NSV>(notSetValue: NSV): T | NSV;
last(): T | undefined;`}
/>

## Conversion to JavaScript types

<MemberLabel label="toJS()" />

Deeply converts this Indexed Seq to equivalent native JavaScript Array.

<Signature code={`toJS(): Array<DeepCopy<T>>;`} />

<MemberLabel label="toJSON()" />

Shallowly converts this Indexed Seq to equivalent native JavaScript Array.

<Signature code={`toJSON(): Array<T>;`} />

<MemberLabel label="toArray()" />

Shallowly converts this collection to an Array.

<Signature code={`toArray(): Array<T>;`} />

<MemberLabel label="toObject()" />

Shallowly converts this Collection to an Object.

<Signature code={`toObject(): { [key: string]: T };`} />

Converts keys to Strings.

## Conversion to Seq

<MemberLabel label="toSeq()" />

Returns Seq.Indexed.

<Signature code={`toSeq(): Seq.Indexed<T>;`} />

<MemberLabel label="fromEntrySeq()" />

If this is a collection of [key, value] entry tuples, it will return a Seq.Keyed of those entries.

<Signature code={`fromEntrySeq(): Seq.Keyed<unknown, unknown>;`} />

<MemberLabel label="toKeyedSeq()" />

Returns a Seq.Keyed with the same key-value entries as this Collection.Indexed.

<Signature code={`toKeyedSeq(): Seq.Keyed<number, T>;`} />

<MemberLabel label="toIndexedSeq()" />

Returns a Seq.Indexed with the same values as this Collection.Indexed.

<Signature code={`toIndexedSeq(): Seq.Indexed<T>;`} />

<MemberLabel label="toSetSeq()" />

Returns a Seq.Set with the same values as this Collection.Indexed.

<Signature code={`toSetSeq(): Seq.Set<T>;`} />

## Combination

<MemberLabel label="interpose()" />

Returns a Collection of the same type with `separator` between each item in this Collection.

<Signature code={`interpose(separator: T): this;`} />

<MemberLabel label="interleave()" />

Returns a Collection of the same type with the provided `collections` interleaved into this collection.

<Signature
  code={`interleave(...collections: Array<Collection<unknown, T>>): this;`}
/>

The resulting Collection includes the first item from each, then the second from each, etc.

<Repl
  defaultValue={`Collection.Indexed([1, 2, 3]).interleave(List(['A', 'B', 'C']));`}
/>

The shortest Collection stops interleave.

<Repl
  defaultValue={`Collection.Indexed([1, 2, 3]).interleave(List(['A', 'B']), List(['X', 'Y', 'Z']));`}
/>

Since `interleave()` re-indexes values, it produces a complete copy, which has `O(N)` complexity.

Note: `interleave` _cannot_ be used in `withMutations`.

<MemberLabel label="splice()" />

Splice returns a new indexed Collection by replacing a region of this Collection with new values. If values are not provided, it only skips the region to be removed.

<Signature
  code={`splice(index: number, removeNum: number, ...values: Array<T>): this;`}
/>

`index` may be a negative number, which indexes back from the end of the Collection. `s.splice(-2)` splices after the second to last item.

<Repl
  defaultValue={`Collection.Indexed(['a', 'b', 'c', 'd']).splice(1, 2, 'q', 'r', 's');`}
/>

Since `splice()` re-indexes values, it produces a complete copy, which has `O(N)` complexity.

Note: `splice` _cannot_ be used in `withMutations`.

<MemberLabel label="zip()" />

Returns a Collection of the same type "zipped" with the provided collections.

<Signature
  code={`zip<U>(other: Collection<unknown, U>): Seq.Indexed<[T, U]>;`}
/>
<Signature
  code={`zip<U, V>(other: Collection<unknown, U>, other2: Collection<unknown, V>): Seq.Indexed<[T, U, V]>;`}
/>
<Signature
  code={`zip(...collections: Array<Collection<unknown, unknown>>): Seq.Indexed<unknown>;`}
/>

Like `zipWith`, but using the default `zipper`: creating an `Array`.

<Repl
  defaultValue={`const a = Collection.Indexed([1, 2, 3]);
const b = Collection.Indexed([4, 5, 6]);
a.zip(b);`}
/>

<MemberLabel label="zipAll()" />

Returns a Collection "zipped" with the provided collections. Unlike `zip`, `zipAll` continues zipping until the longest collection is exhausted. Missing values from shorter collections are filled with `undefined`.

<Signature
  code={`zipAll<U>(other: Collection<unknown, U>): Seq.Indexed<[T, U]>;`}
/>
<Signature
  code={`zipAll<U, V>(other: Collection<unknown, U>, other2: Collection<unknown, V>): Seq.Indexed<[T, U, V]>;`}
/>
<Signature
  code={`zipAll(...collections: Array<Collection<unknown, unknown>>): Seq.Indexed<unknown>;`}
/>

<Repl
  defaultValue={`const a = Collection.Indexed([1, 2]);
const b = Collection.Indexed([3, 4, 5]);
a.zipAll(b);`}
/>

<MemberLabel label="zipWith()" />

Returns a Collection of the same type "zipped" with the provided collections by using a custom `zipper` function.

<Signature
  code={`zipWith<U, Z>(zipper: (value: T, otherValue: U) => Z, otherCollection: Collection<unknown, U>): Collection.Indexed<Z>;`}
/>
<Signature
  code={`zipWith<U, V, Z>(zipper: (value: T, otherValue: U, thirdValue: V) => Z, otherCollection: Collection<unknown, U>, thirdCollection: Collection<unknown, V>): Seq.Indexed<Z>;`}
/>
<Signature
  code={`zipWith<Z>(zipper: (...values: Array<unknown>) => Z, ...collections: Array<Collection<unknown, unknown>>): Seq.Indexed<Z>;`}
/>

<Repl
  defaultValue={`const a = Collection.Indexed([1, 2, 3]);
const b = Collection.Indexed([4, 5, 6]);
a.zipWith((a, b) => a + b, b);`}
/>

<MemberLabel label="flatten()" />

Flattens nested Collections.

<Signature code={`flatten(depth?: number): Collection<unknown, unknown>;`} />
<Signature code={`flatten(shallow?: boolean): Collection<unknown, unknown>;`} />

Will deeply flatten the Collection by default, returning a Collection of the same type, but a `depth` can be provided in the form of a number or boolean (where true means to shallowly flatten one level). A depth of 0 (or shallow: false) will deeply flatten.

Flattens only others Collection, not Arrays or Objects.

Note: `flatten(true)` operates on `Collection<unknown, Collection<K, V>>` and returns `Collection<K, V>`

## Search for value

<MemberLabel label="indexOf()" />

Returns the first index at which a given value can be found in the Collection, or -1 if it is not present.

<Signature code={`indexOf(searchValue: T): number;`} />

<MemberLabel label="lastIndexOf()" />

Returns the last index at which a given value can be found in the Collection, or -1 if it is not present.

<Signature code={`lastIndexOf(searchValue: T): number;`} />

<MemberLabel label="findIndex()" />

Returns the first index in the Collection where a value satisfies the provided predicate function. Otherwise -1 is returned.

<Signature
  code={`findIndex(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): number;`}
/>

<MemberLabel label="findLastIndex()" />

Returns the last index in the Collection where a value satisfies the provided predicate function. Otherwise -1 is returned.

<Signature
  code={`findLastIndex(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): number;`}
/>

<MemberLabel label="find()" />

Returns the first value for which the `predicate` returns true.

<Signature
  code={`find(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): T | undefined;`}
/>

<MemberLabel label="findLast()" />

Returns the last value for which the `predicate` returns true.

<Signature
  code={`findLast(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): T | undefined;`}
/>

Note: `predicate` will be called for each entry in reverse.

<MemberLabel label="findEntry()" />

Returns the first [key, value] entry for which the `predicate` returns true.

<Signature
  code={`findEntry(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): [number, T] | undefined;`}
/>

<MemberLabel label="findLastEntry()" />

Returns the last [key, value] entry for which the `predicate` returns true.

<Signature
  code={`findLastEntry(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): [number, T] | undefined;`}
/>

<MemberLabel label="findKey()" />

Returns the key for which the `predicate` returns true.

<Signature
  code={`findKey(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): number | undefined;`}
/>

<MemberLabel label="findLastKey()" />

Returns the last key for which the `predicate` returns true.

<Signature
  code={`findLastKey(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): number | undefined;`}
/>

Note: `predicate` will be called for each entry in reverse.

<MemberLabel label="keyOf()" />

Returns the key associated with the search value, or undefined.

<Signature code={`keyOf(searchValue: T): number;`} />

<MemberLabel label="lastKeyOf()" />

Returns the last key associated with the search value, or undefined.

<Signature code={`lastKeyOf(searchValue: T): number;`} />

<MemberLabel label="max()" />

Returns the maximum value in this collection. If any values are comparatively equivalent, the first one found will be returned.

<Signature code={`max(comparator?: Comparator<T>): T | undefined;`} />

The `comparator` is used in the same way as `Collection#sort`. If it is not provided, the default comparator is `>`.

When two values are considered equivalent, the first encountered will be returned. Otherwise, `max` will operate independent of the order of input as long as the comparator is commutative. The default comparator `>` is commutative _only_ when types do not differ.

If `comparator` returns 0 and either value is NaN, undefined, or null, that value will be returned.

<MemberLabel label="maxBy()" />

Like `max`, but also accepts a `comparatorValueMapper` which allows for comparing by more sophisticated means.

<Signature
  code={`maxBy<C>(comparatorValueMapper: (value: T, key: number, iter: this) => C, comparator?: Comparator<C>): T | undefined;`}
/>

<Repl
  defaultValue={`const l = List([
  { name: 'Bob', avgHit: 1 },
  { name: 'Max', avgHit: 3 },
  { name: 'Lili', avgHit: 2 } ,
]);
l.maxBy(i => i.avgHit);`}
/>

<MemberLabel label="min()" />

Returns the minimum value in this collection. If any values are comparatively equivalent, the first one found will be returned.

<Signature code={`min(comparator?: Comparator<T>): T | undefined;`} />

The `comparator` is used in the same way as `Collection#sort`. If it is not provided, the default comparator is `<`.

When two values are considered equivalent, the first encountered will be returned. Otherwise, `min` will operate independent of the order of input as long as the comparator is commutative. The default comparator `<` is commutative _only_ when types do not differ.

If `comparator` returns 0 and either value is NaN, undefined, or null, that value will be returned.

<MemberLabel label="minBy()" />

Like `min`, but also accepts a `comparatorValueMapper` which allows for comparing by more sophisticated means.

<Signature
  code={`minBy<C>(comparatorValueMapper: (value: T, key: number, iter: this) => C, comparator?: Comparator<C>): T | undefined;`}
/>

<Repl
  defaultValue={`const l = List([
  { name: 'Bob', avgHit: 1 },
  { name: 'Max', avgHit: 3 },
  { name: 'Lili', avgHit: 2 } ,
]);
l.minBy(i => i.avgHit);`}
/>

## Sequence algorithms

<MemberLabel label="concat()" />

Returns a new Seq with other collections concatenated to this one.

<Signature
  code={`concat<C>(...valuesOrCollections: Array<Iterable<C> | C>): Seq.Indexed<T | C>;`}
/>

<MemberLabel label="map()" />

Returns a new Seq.Indexed with values passed through a `mapper` function.

<Signature
  code={`map<M>(mapper: (value: T, key: number, iter: this) => M, context?: unknown): Seq.Indexed<M>;`}
/>

<Repl defaultValue={`Seq.Indexed([1, 2]).map((x) => 10 * x)`} />

Note: `map()` always returns a new instance, even if it produced the same value at every step.

<MemberLabel label="flatMap()" />

Flat-maps the Seq, returning a Seq of the same type.

<Signature
  code={`flatMap<M>(mapper: (value: T, key: number, iter: this) => Iterable<M>, context?: unknown): Seq.Indexed<M>;`}
/>

Similar to `seq.map(...).flatten(true)`.

<MemberLabel label="filter()" />

Returns a new Collection with only the values for which the `predicate` function returns true.

<Signature
  code={`filter<F extends T>(predicate: (value: T, index: number, iter: this) => value is F, context?: unknown): Seq.Indexed<F>;`}
/>
<Signature
  code={`filter(predicate: (value: T, index: number, iter: this) => unknown, context?: unknown): this;`}
/>

Note: `filter()` always returns a new instance, even if it results in not filtering out any values.

<MemberLabel label="partition()" />

Returns a new indexed Seq with the values for which the `predicate` function returns false and another for which is returns true.

<Signature
  code={`partition<F extends T, C>(predicate: (this: C, value: T, index: number, iter: this) => value is F, context?: C): [Seq.Indexed<T>, Seq.Indexed<F>];`}
/>
<Signature
  code={`partition<C>(predicate: (this: C, value: T, index: number, iter: this) => unknown, context?: C): [this, this];`}
/>

<MemberLabel label="[Symbol.iterator]()" />

<Signature code={`[Symbol.iterator](): IterableIterator<T>;`} />

<MemberLabel label="filterNot()" />

Returns a new Collection with only the values for which the `predicate` function returns false.

<Signature
  code={`filterNot(predicate: (value: T, index: number, iter: this) => unknown, context?: unknown): this;`}
/>

<Repl defaultValue={`Collection.Indexed([1, 2, 3]).filterNot((x) => x > 2)`} />

Note: `filterNot()` always returns a new instance, even if it results in not filtering out any values.

<MemberLabel label="reverse()" />

Returns a new Collection with the values in reverse order.

<Signature code={`reverse(): this;`} />

<MemberLabel label="sort()" />

Returns a new sorted Collection, sorted by the natural order of the values.

<Signature code={`sort(): Collection.Indexed<T>;`} />

If a `comparator` is not provided, a default comparator uses `<` and `>`.

Note: `sort()` always returns a new instance, even if the original was already sorted.

Note: This is always an eager operation.

<MemberLabel label="sortBy()" />

Returns a new sorted Collection, sorted by the provided `comparator` function.

<Signature
  code={`sortBy<R>(comparator: (value: T) => R): Collection.Indexed<T>;`}
/>

Note: `sortBy()` always returns a new instance, even if the original was already sorted.

Note: This is always an eager operation.

<MemberLabel label="groupBy()" />

Groups the values by the return value of the `mapper` function, and returns a Collection.Indexed of Arrays of grouped values.

<Signature
  code={`groupBy<K>(mapper: (value: T) => K): Collection.Indexed<Array<T>>;`}
/>

## Value equality

<MemberLabel label="equals()" />

Returns true if the Collections are of the same size and all values are equal.

<Signature code={`equals(other: unknown): other is this;`} />

<MemberLabel label="hashCode()" />

Returns a hash code for this Collection.

<Signature code={`hashCode(): number;`} />

## Reading deep values

<MemberLabel label="getIn()" />

Returns the value at the given nested path, or notSetValue if any key in the path is not present.

<Signature
  code={`getIn<NSV>(path: Array<string | number>, notSetValue: NSV): T | NSV;`}
/>
<Signature code={`getIn(path: Array<string | number>): T | undefined;`} />

<MemberLabel label="hasIn()" />

Returns a boolean if the given nested path exists.

<Signature code={`hasIn(path: Array<string | number>): boolean;`} />

## Persistent changes

<MemberLabel label="update()" />

Returns a new Collection.Indexed with the value at the given index updated to the new value.

<Signature code={`update(index: number, updater: (value: T) => T): this;`} />

## Conversion to Collections

<MemberLabel label="toMap()" />

Converts this Collection.Indexed to a Map. The first value of each entry is used as the key.

<Signature code={`toMap(): Collection.Keyed<T, T>;`} />

<MemberLabel label="toOrderedMap()" />

Converts this Collection.Indexed to an OrderedMap. The first value of each entry is used as the key.

<Signature code={`toOrderedMap(): Collection.OrderedKeyed<T, T>;`} />

<MemberLabel label="toSet()" />

Converts this Collection.Indexed to a Set.

<Signature code={`toSet(): Collection.Set<T>;`} />

<MemberLabel label="toOrderedSet()" />

Converts this Collection.Indexed to an OrderedSet.

<Signature code={`toOrderedSet(): Collection.OrderedSet<T>;`} />

<MemberLabel label="toList()" />

Converts this Collection.Indexed to a List.

<Signature code={`toList(): Collection.Indexed<T>;`} />

<MemberLabel label="toStack()" />

Converts this Collection.Indexed to a Stack.

<Signature code={`toStack(): Collection.Indexed<T>;`} />

## Iterators

<MemberLabel label="keys()" />

Returns an Iterable of the keys in the Collection.

<Signature code={`keys(): Iterable<number>;`} />

<MemberLabel label="values()" />

Returns an Iterable of the values in the Collection.

<Signature code={`values(): Iterable<T>;`} />

<MemberLabel label="entries()" />

Returns an Iterable of the [key, value] entries in the Collection.

<Signature code={`entries(): Iterable<[number, T]>;`} />

## Collections (Seq)

<MemberLabel label="keySeq()" />

Returns a Seq of the keys in the Collection.

<Signature code={`keySeq(): Seq.Indexed<number>;`} />

<MemberLabel label="valueSeq()" />

Returns a Seq of the values in the Collection.

<Signature code={`valueSeq(): Seq.Indexed<T>;`} />

<MemberLabel label="entrySeq()" />

Returns a Seq of the [key, value] entries in the Collection.

<Signature code={`entrySeq(): Seq.Indexed<[number, T]>;`} />

## Side effects

<MemberLabel label="forEach()" />

Calls the provided function for each value in the Collection. Returns the Collection.

<Signature
  code={`forEach(fn: (value: T, index: number, iter: this) => void, context?: unknown): this;`}
/>

## Creating subsets

<MemberLabel label="slice()" />

Returns a new Collection.Indexed with the values between the given start and end indices.

<Signature code={`slice(begin?: number, end?: number): this;`} />

<MemberLabel label="rest()" />

Returns a new Collection.Indexed with all but the first value.

<Signature code={`rest(): this;`} />

<MemberLabel label="butLast()" />

Returns a new Collection.Indexed with all but the last value.

<Signature code={`butLast(): this;`} />

<MemberLabel label="skip()" />

Returns a new Collection.Indexed with the first `n` values removed.

<Signature code={`skip(n: number): this;`} />

<MemberLabel label="skipLast()" />

Returns a new Collection.Indexed with the last `n` values removed.

<Signature code={`skipLast(n: number): this;`} />

<MemberLabel label="skipWhile()" />

Returns a new Collection.Indexed with values skipped while the `predicate` function returns true.

<Signature
  code={`skipWhile(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): this;`}
/>

<MemberLabel label="skipUntil()" />

Returns a new Collection.Indexed with values skipped until the `predicate` function returns true.

<Signature
  code={`skipUntil(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): this;`}
/>

<MemberLabel label="take()" />

Returns a new Collection.Indexed with the first `n` values.

<Signature code={`take(n: number): this;`} />

<MemberLabel label="takeLast()" />

Returns a new Collection.Indexed with the last `n` values.

<Signature code={`takeLast(n: number): this;`} />

<MemberLabel label="takeWhile()" />

Returns a new Collection.Indexed with values taken while the `predicate` function returns true.

<Signature
  code={`takeWhile(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): this;`}
/>

<MemberLabel label="takeUntil()" />

Returns a new Collection.Indexed with values taken until the `predicate` function returns true.

<Signature
  code={`takeUntil(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): this;`}
/>

## Reducing a value

<MemberLabel label="reduce()" />

Returns the accumulated result of calling the provided reducer function for each value in the Collection, from left to right.

<Signature
  code={`reduce<R>(reducer: (previousValue: R | T, currentValue: T, index: number, iter: this) => R, initialValue?: R): R;`}
/>

<MemberLabel label="reduceRight()" />

Returns the accumulated result of calling the provided reducer function for each value in the Collection, from right to left.

<Signature
  code={`reduceRight<R>(reducer: (previousValue: R | T, currentValue: T, index: number, iter: this) => R, initialValue?: R): R;`}
/>

<MemberLabel label="every()" />

Returns true if the `predicate` function returns a truthy value for every value in the Collection.

<Signature
  code={`every(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): boolean;`}
/>

<MemberLabel label="some()" />

Returns true if the `predicate` function returns a truthy value for any value in the Collection.

<Signature
  code={`some(predicate: (value: T, index: number, iter: this) => boolean, context?: unknown): boolean;`}
/>

<MemberLabel label="join()" />

Returns the concatenated string result of calling `String(value)` on every value in the Collection, separated by the given separator string.

<Signature code={`join(separator?: string): string;`} />

<MemberLabel label="isEmpty()" />

Returns true if the Collection has no values.

<Signature code={`isEmpty(): boolean;`} />

<MemberLabel label="count()" />

Returns the number of values in the Collection.

<Signature code={`count(): number;`} />

<MemberLabel label="countBy()" />

Returns a new Collection.Indexed with the number of times each value occurs in the Collection.

<Signature code={`countBy(): Collection.Indexed<number>;`} />

## Comparison

<MemberLabel label="isSubset()" />

Returns true if this Collection.Indexed is a subset of the other Collection (i.e. all values in this Collection.Indexed are also in the other).

<Signature code={`isSubset(other: unknown): other is this;`} />

<MemberLabel label="isSuperset()" />

Returns true if this Collection.Indexed is a superset of the other Collection (i.e. this Collection.Indexed contains all values of the other).
